home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / unix / volume15 / hash8 < prev    next >
Encoding:
Internet Message Format  |  1988-06-05  |  32.6 KB
  1. Subject:  v15i036:  Hash long identifiers into unique short ones
  2. Newsgroups: comp.sources.unix
  3. Sender: sources
  4. Approved: rsalz@uunet.UU.NET
  5.  
  6. Submitted-by: desint!geoff (Geoff Kuenning)
  7. Posting-number: Volume 15, Issue 36
  8. Archive-name: hash8
  9.  
  10. [  I haven't used this; documentation is in the README files as use
  11.    is likely to be very system-dependent. --r$  ]
  12.  
  13. This is Arch Robison's "hash8" program, which allows old C compilers
  14. to compile long-identifier programs correctly.  I have added an "lcc"
  15. ("longname-cc") shell script to make this even easier.  Useful with
  16. ispell and nethack.
  17.  
  18.     Geoff Kuenning   geoff@ITcorp.com   {uunet,trwrb}!desint!geoff
  19.  
  20. #! /bin/sh
  21. # This is a shell archive, meaning:
  22. # 1. Remove everything above the #! /bin/sh line.
  23. # 2. Save the resulting text in a file.
  24. # 3. Execute the file with /bin/sh (not csh) to create the files:
  25. #    README
  26. #    README.OLD
  27. #    DOC
  28. #    Makefile
  29. #    hash8.c
  30. #    lcc.sh,v
  31. #    ltest.c
  32. #    ltest2.c
  33. #    ltest3.c
  34. #    ncc
  35. export PATH; PATH=/bin:$PATH
  36. echo shar: extracting "'README'" '(873 characters)'
  37. if test -f 'README'
  38. then
  39.     echo shar: will not over-write existing file "'README'"
  40. else
  41. cat << \SHAR_EOF > 'README'
  42.  
  43.     An Improved Version of Arch Robison's "hash8"
  44.  
  45. Some time ago, Arch Robison kindly provided me with a copy of his
  46. "hash8" program, which gives long-id capabilities to all C compilers.
  47. Briefly, hash8 replaces all long identifiers in a program with a
  48. numerically-based identifier of 6 characters.  Options allow things
  49. like using debuggers with the original long names.
  50.  
  51. I have extended Arch's program with a shell script, "lcc.sh", which
  52. does exactly what "cc" does, but compiles long-name programs.  Unfortunately,
  53. the script is quite system-specific, and I have an odd configuration
  54. (68000 running UniSoft System V.0 with V7 compilers), so you will
  55. almost certainly have to edit it before it is completely compatible
  56. with your own "cc".  Nevertheless, for those with older compilers,
  57. this is a life-saver.
  58.  
  59.     Geoff Kuenning   geoff@ITcorp.com   {uunet,trwrb}!desint!geoff
  60. SHAR_EOF
  61. fi # end of overwriting check
  62. echo shar: extracting "'README.OLD'" '(1303 characters)'
  63. if test -f 'README.OLD'
  64. then
  65.     echo shar: will not over-write existing file "'README.OLD'"
  66. else
  67. cat << \SHAR_EOF > 'README.OLD'
  68. >From uucp Sat Oct 25 02:45 PDT 1986
  69. >From ihnp4!uiucdcs!b.cs.uiuc.edu!robison  Sat Oct 25 02:45:46 1986 remote from trwrb
  70. Received: by ihnp4.ATT.COM id AA14044; 22 Oct 86 15:34:56 CDT (Wed)
  71. Received: from b.cs.uiuc.edu by a.cs.uiuc.edu with SMTP (UIUC-5.44/9.7),
  72.     id AA26838; Wed, 22 Oct 86 11:29:19 CDT
  73. Received: by b.cs.uiuc.edu (UIUC-5.44/9.7),
  74.     id AA04280; Wed, 22 Oct 86 11:25:50 CDT
  75. Date: Wed, 22 Oct 86 11:25:50 CDT
  76. From: trwrb!ihnp4!uiucdcs!b.cs.uiuc.edu!robison (Arch Robison)
  77. Message-Id: <8610221625.AA04280@b.cs.uiuc.edu>
  78. To: desint!geoff
  79. Subject: long-to-short converter
  80.  
  81.  
  82. Here is the long-identifier converter.  The converter has been used
  83. to create a long-identifier lint and with cc.  Please send me any bug
  84. reports or comments on how to improve it.  My version of lint that uses 
  85. it has been running for nearly a year now without problems.  Since lint
  86. is a licensed program, I can't send you a copy, though it shouldn't be 
  87. hard to figure out how to modify it.  (Lint is a shell script.)
  88.  
  89. To use hash8 with debuggers, you will want to modify it to turn off 
  90. stdin/stdout buffering.
  91.  
  92. To compile the program, make a directory and run the shell script below.
  93. Then "make hash8".
  94.  
  95. - Arch D. Robison
  96.   Dept. of Computer Science
  97.   University of Illinois at Urbana-Champaign
  98.  
  99.   robison@uiucdcs
  100.  
  101. SHAR_EOF
  102. fi # end of overwriting check
  103. echo shar: extracting "'DOC'" '(1324 characters)'
  104. if test -f 'DOC'
  105. then
  106.     echo shar: will not over-write existing file "'DOC'"
  107. else
  108. cat << \SHAR_EOF > 'DOC'
  109. Hash8 documentation                Arch D. Robison
  110.                         University of Illinois
  111.                         Urbana Champaign
  112.  
  113.                         robison@uiucdcs
  114.  
  115.             Hash8 
  116.  
  117. There three files (other than DOC) provided:
  118.  
  119.     hash8.c     source code for long identifier converter
  120.     Makefile    example makefile
  121.     ncc        shell script for compiling
  122.  
  123. The hash8 program allows short-identifier C compilers to compile
  124. long-identifier programs.  It is not intened for production use,
  125. but for quickly porting long-identifier programs.
  126.  
  127. See the documentation in hash8.c and the Makefile for how to use it with cc.
  128.  
  129. ----------------------------------------------------------------------
  130.  
  131.             Hash8 with lint
  132.  
  133. I've been able to hack a short identifier lint with "hash8" so it would work
  134. with long identifier programs.  This was an easy modification since lint is
  135. a shell script.  The "hash8 encode" filter was put in between /lib/cpp and 
  136. /usr/lib/lint/lint and all error message written to a temporary file.
  137. Then "hash8 decode" was used to decode the error messages.
  138.  
  139. Note that hash8's can not run in parallel, since the identifier map is read all
  140. at once and written all at once.
  141.  
  142. Thus you can't (regrettably) do: 
  143.  
  144.      hash8 encode TABLE | /lib/cpp | hash8 decode TABLE
  145.  
  146. The above would have to be written:
  147.  
  148.      hash8 encode TABLE >TEMP
  149.      cat TEMP | /lib/cpp | hash8 decode TABLE
  150.  
  151. SHAR_EOF
  152. fi # end of overwriting check
  153. echo shar: extracting "'Makefile'" '(1829 characters)'
  154. if test -f 'Makefile'
  155. then
  156.     echo shar: will not over-write existing file "'Makefile'"
  157. else
  158. cat << \SHAR_EOF > 'Makefile'
  159. # Here is the original makefile for a sample program with long identifiers.
  160. #
  161. #snakeomatic:    main.o move.o screen.o
  162. #        cc main.o move.o screen.o -lm
  163. #
  164. #main.o:    snakeomatic.h main.c
  165. #        cc -c main.c
  166. #
  167. #move.o:        snakeomatic.h move.c
  168. #        cc -c move.c
  169. #
  170. #screen.o:    snakeomatic.h screen.c
  171. #        cc -c screen.c
  172.  
  173. #---------------------------------------------------------------------------
  174. #
  175. # Makefile modified for hash8.  Each source file xxx has been renamed L_xxx.
  176. # The "ncc" shell script filters each L_xxx file with hash8 and puts
  177. # the result in file xxx, which is then compiled.
  178. #
  179. # Also note that any .h file must also be filtered by hash8.
  180. #
  181. # The file TABLE is the identifier mapping table.  You should "make TABLE"
  182. # before your first compilation to initilize the mapping table.
  183. # After that, you should not have to remake the table, even if you
  184. # make corrections in the code.  Hash8 will automatically update
  185. # the table when necessary.
  186. #
  187. SYSTEM = /usr/include/stdio /usr/include/signal.h /usr/include/sgtty.h 
  188.  
  189. snakeomatic:    main.o move.o screen.o
  190.         cc main.o move.o screen.o -lm 2>&1 | hash8 _decode TABLE
  191.  
  192. main.o:        snakeomatic.h L_main.c
  193.         ncc main.c
  194.  
  195. move.o:        snakeomatic.h L_move.c
  196.         ncc move.c
  197.  
  198. screen.o:    snakeomatic.h L_screen.c
  199.         ncc screen.c
  200.  
  201. snakeomatic.h:  L_snakeomatic.h
  202.         cat L_snakeomatic.h | hash8 encode TABLE >snakeomatic.h
  203.  
  204. #
  205. # When the identifier map is first created, all the system #include files
  206. # should be run through hash8.  This usually not necessary, but it
  207. # is possible that your program's identifiers could have a common prefix
  208. # with a system identifier.  By processing the system #include files first,
  209. # we ensure that those identifiers will not be changed.
  210. #
  211. TABLE:        hash8 $(SYSTEM)
  212.         rm -f TABLE
  213.         cat $(SYSTEM) | hash8 encode TABLE >/dev/null
  214.  
  215. hash8:        hash8.c
  216.         cc $(CFLAGS) hash8.c -o hash8
  217. SHAR_EOF
  218. fi # end of overwriting check
  219. echo shar: extracting "'hash8.c'" '(11200 characters)'
  220. if test -f 'hash8.c'
  221. then
  222.     echo shar: will not over-write existing file "'hash8.c'"
  223. else
  224. cat << \SHAR_EOF > 'hash8.c'
  225. /*
  226.  * Date: March 17 1985            Author: Arch D. Robison
  227.  *                        Dept. of Computer Science
  228.  *                        University of Illinois
  229.  *                        Urbana-Champaign
  230.  *
  231.  *                    USENET:    robison@uiucdcs
  232.  *
  233.  * Hash8 copies stdin to stdout, while replacing certain identifiers.
  234.  * lint can be converted to accept long identifiers by hacking in hash8
  235.  * between /lib/cpp and /usr/lib/lint/lint appropriately.
  236.  *
  237.  * There are three ways to call hash8:
  238.  *
  239.  *     hash8 encode table
  240.  *         Map long identifiers and those beginning with Q 
  241.  *       into short identifiers Q%d
  242.  *
  243.  *     hash8 decode table
  244.  *         Map short identifiers Q%d into their long equivalents
  245.  *
  246.  *     hash8 _decode table
  247.  *         Map short identifiers _Q%d into their long equivalents
  248.  *        This is used to decode the linker's error messages
  249.  *
  250.  * The 'table' argument is the file name for the identifier map.
  251.  * The 'encode' calls will either create or expand the table.
  252.  *
  253.  * Typically, the encode option is used to preprocess input to the compiler
  254.  * or lint, and the decode option is used to decode error messages from
  255.  * the compiler.
  256.  *
  257.  * The constant HASHBITS may need to be changed.  It is the base two
  258.  * log of the number of distinct long identifiers which may be found.
  259.  * E.g. the value of 12 allows for 4096 long identifiers.
  260.  *
  261.  * Hash8 has not been thoroughly tested, though it can translate itself
  262.  * correctly.  Note that itself contains all sorts of quotes within quotes.
  263.  */
  264. #include <stdio.h>
  265. #include <ctype.h>
  266.  
  267. /*
  268.  * Reserved is an array of words which we don't want modified, such
  269.  * as the key word "register", or system functions longer than 7 characters.
  270.  * Feel free to add any others, though remember to clear your hash table
  271.  * files after recompiling.
  272.  */
  273. char **Reserved = NULL;
  274. int Res_max = 0;
  275. int Res_count = 0;
  276. char *Def_reserved[] = {
  277.    "continue",
  278.    "register",
  279.    "unsigned"
  280. };
  281.  
  282. extern char *malloc (), *strcpy ();
  283.  
  284. #define SIGCHARS 7        /* significant characters in identifier */
  285. #define HASHBITS 12        /* hash table address size */
  286. #define HASHLIMIT (1<<HASHBITS)
  287. #define HASHMASK (HASHLIMIT-1)
  288. #define PAGESIZE 4096        /* Memory allocation pagesize */ 
  289. #define MAXLINE 1024        /* Maximum length of a source line allowed */
  290.  
  291. #define W_SHORTEN  0        /* Identifier classes */
  292. #define W_NORMAL   1
  293. #define W_RESERVED 2
  294. #define W_Valid(N) ((N) >= 0 && (N) <= 2)
  295.  
  296. /*
  297.  * HashTab
  298.  *
  299.  * The identifier map is a hash table.  The table uses open addressing
  300.  * with linear probing for collision resolution.  Identifiers in the
  301.  * table are mapped into Qxxx, where xxx is the table address in hex.
  302.  *
  303.  * The hash table is effectively declared:
  304.  *
  305.  *      char *HashTab[HASHLIMIT];
  306.  *
  307.  * though the memory allocation is done with malloc.  Each empty hash table
  308.  * item is NULL.  Full entries point to an identifier.  The first byte of
  309.  * the identifier classifies the identifier:
  310.  *
  311.  *      W_NORMAL - don't modify this identifier
  312.  *    W_SHORTEN - shorten this identifier
  313.  *    W_RESERVE - reserved word 
  314.  */
  315. char **HashTab;
  316. int HashSize = 0;    /* Number of elements in hash table             */
  317. int NewTab;          /* Flag which is set to true if hash table is modified */
  318.  
  319. char *StrFree;         /* Pointer to base of free string area                 */
  320. int StrLeft = 0;     /* Number of characters left in free string area       */
  321.  
  322. /*
  323.  * Insert
  324.  * 
  325.  * Insert identifier in hash table
  326.  *
  327.  * In
  328.  *      k = index into hash table
  329.  *      S = identifier
  330.  *    Class = class of identifier (W_NORMAL,W_SHORTEN,W_RESERVED)
  331.  */
  332. void Insert (k,S,Class)
  333.    int k;
  334.    char *S;
  335.    int Class;
  336.    {
  337.       register int L;
  338.  
  339.       NewTab = 1;
  340.       HashSize++;
  341.       if ((StrLeft -= (L=2+strlen (S))) < 0)
  342.          StrFree = malloc (StrLeft=PAGESIZE);
  343.       *(HashTab[k] = StrFree) = Class;
  344.       strcpy (StrFree+1, S);
  345.       StrFree += L;
  346.       StrLeft -= L;
  347.    }               
  348.  
  349. /*
  350.  * LookUp
  351.  *
  352.  * Look up an identifer in the identifier hash table.
  353.  * If not found, then insert it in the table.
  354.  *
  355.  * The hashing uses open addressing with linear probing.
  356.  * The algorithm is a blue-light special, a better hash function
  357.  * (double hashing?) should be used.
  358.  * 
  359.  * In
  360.  *      S = identifier (must be at least seven characters if Duplicate == 0)
  361.  *      Class = identifier class (W_NORMAL,W_SHORTEN,W_RESERVED)
  362.  * Out
  363.  *      result = index into hash table 
  364.  */
  365. int LookUp (S,Class)
  366.    char *S;
  367.    int Class;
  368.    {
  369.       register int k,j;
  370.       register char *T;
  371.  
  372.       if (Class != W_SHORTEN) {
  373.  
  374.          /* Hash first seven characters of identifier */ 
  375.          for (j=0,k=0,T=S; j<SIGCHARS; j++, k+= *T++) k = (k<<1) + k;
  376.  
  377.          /* 7-character search for identifier in table */
  378.          for (j=k; HashTab[j&=HASHMASK] != NULL; j++) 
  379.             if (!strncmp (HashTab[j]+1,S,SIGCHARS)) 
  380.                if (!strcmp (HashTab[j]+1,S)) return j;
  381.            else {
  382.           Class = W_SHORTEN;
  383.           break;
  384.            }
  385.      /* The following test and assignment cause identifiers to be
  386.       * hashed even if they are the first long identifier.  This
  387.       * protects from truncation by the compiler.  Othewise, when
  388.       * you run adb you have to know which long id came first.
  389.       * Geoff Kuenning 11/8/86
  390.       */
  391.          if (Class == W_NORMAL  &&  strlen (S) > SIGCHARS)
  392.         Class = W_SHORTEN;
  393.       }
  394.  
  395.       if (Class == W_SHORTEN) {
  396.      /* 
  397.       * There is another identifier with the same 7-character prefix. 
  398.       * Hash the complete identifier and look it up in the table.
  399.       */
  400.          for (j=k; *T; j+= *T++) j = (j<<1) + j;
  401.  
  402.      /* all characters search for identifier in table */
  403.      for (; HashTab[j&=HASHMASK] != NULL; j++)
  404.            if (!strcmp (HashTab[j]+1,S)) return j;
  405.       }
  406.  
  407.       /* Identifier was not found - insert it in hash table */
  408.       Insert (j,S,Class);
  409.       if (HashSize == HASHLIMIT) 
  410.      fprintf (stderr,"hash8: table overflow\n"), exit (1);
  411.       return j;
  412.    }
  413.  
  414. #define C_CODE 0    /* Defines for translator states */
  415. #define S_QUOTE 1
  416. #define D_QUOTE 2
  417. #define COMMENT 3
  418.  
  419. #define ENCODE 0    /* Mode values for translator */
  420. #define DECODE 1
  421. #define _DECODE 2
  422.  
  423. /*
  424.  * Translate
  425.  *
  426.  * Translate input stream with identifier map.
  427.  *
  428.  * This should have been written with lex.
  429.  */
  430. Translate (Mode) 
  431.    int Mode;
  432.    {
  433.       register char C, *P, *Q;
  434.       char S[MAXLINE];
  435.       int k, state=C_CODE, IsQ;
  436.  
  437.       while (NULL != fgets (S,MAXLINE,stdin)) 
  438.          for (P=S; C= *P; )
  439.         switch (state) {
  440.            case COMMENT:
  441.               putchar (*P++);
  442.                   if (C == '*' && *P == '/') state=C_CODE, putchar (*P++);
  443.           break;
  444.            case S_QUOTE:
  445.            case D_QUOTE:
  446.           putchar (*P++);
  447.           switch (C) {
  448.              case '\'': if (state == S_QUOTE) state = C_CODE; break;
  449.              case '"' : if (state == D_QUOTE) state = C_CODE; break;
  450.              case '\\': putchar (*P++); break;
  451.              default: break; 
  452.           }
  453.               break;
  454.            
  455.                case C_CODE:
  456.           if (isalpha (C) || C=='_') {
  457.                  /* Beginning of identifier */
  458.                        for (Q=P; C= *Q, isalnum(C)||C=='_'; Q++);
  459.                  *Q = '\0';
  460.                     switch (Mode) {
  461.  
  462.             case ENCODE: /* We are encoding C source */
  463.                    IsQ = *P=='Q' && isdigit (P[1]);
  464.                           if (Q-P <= SIGCHARS && !IsQ) 
  465.                              fputs (P,stdout);
  466.                    else {
  467.                   k = LookUp (P,IsQ ? W_SHORTEN : W_NORMAL);
  468.                   if (*HashTab[k] != W_SHORTEN) fputs (P,stdout);
  469.                       else printf ("Q%d",k);
  470.                    }
  471.                break;
  472.  
  473.             case _DECODE: /* We are decoding linker messages */
  474.                    if (*P != '_') {
  475.                   fputs (P,stdout);
  476.                   break;
  477.                }
  478.                putchar (*P++);
  479.                /* continue on down to case DECODE */
  480.  
  481.             case DECODE: /* We are decoding error message */
  482.                           if (*P=='Q' && isdigit (P[1])) { 
  483.                   k=atoi(P+1);
  484.                   if (!(k &~HASHMASK) && HashTab[k]!=NULL) 
  485.                  P = HashTab[k] + 1;
  486.                }
  487.                    fputs (P,stdout);
  488.                break;
  489.              }
  490.                     *(P=Q) = C;
  491.                  } else if (isdigit (C)) {
  492.                  /* Skip number to avoid changing long numbers */
  493.                  while (isalnum(*P)) putchar (*P++);
  494.               } else {
  495.              putchar (*P++);
  496.              switch (C) {
  497.                 default: break;
  498.             case '\'': state = S_QUOTE; break;
  499.                         case '"' : state = D_QUOTE; break;
  500.                         case '/' : if (*P != '*') continue;
  501.                        state=COMMENT;
  502.                 case '\\': putchar (*P++); break;
  503.              }
  504.               }
  505.            }
  506.    }
  507.  
  508. /*
  509.  * ReadTab
  510.  *
  511.  * Read the hash table.
  512.  *
  513.  * In
  514.  *      Name = name of hash table file
  515.  */
  516. ReadTab (Name)
  517.    char *Name;
  518.    {
  519.       FILE *Table;
  520.       char S[MAXLINE];
  521.       int k,L,Class;
  522.  
  523.       /* First record all words we don't want mangled in hash table */      
  524.       for (k = 0;  k < sizeof (Def_reserved) / sizeof (char *);  k++)
  525.          LookUp (Def_reserved[k], W_RESERVED);
  526.       for (k = 0;  k < Res_count;  k++) 
  527.          LookUp (Reserved[k],W_RESERVED);
  528.  
  529.       if (NULL == (Table = fopen (Name,"r"))) return;
  530.       while (EOF != (L = fscanf (Table,"%d %d %s",&k,&Class,S))) 
  531.      if (L != 3 || k &~HASHMASK || !W_Valid (Class))
  532.         fprintf (stderr,"hash8 table error\n"),
  533.         exit (1);
  534.          else Insert (k,S,Class);
  535.       fclose (Table); 
  536.       NewTab = 0;
  537.    }
  538.  
  539. /*
  540.  * WriteTab
  541.  *
  542.  * Write out the hash table
  543.  *
  544.  * In
  545.  *      Name = name of hash table file
  546.  */
  547. WriteTab (Name)
  548.    char *Name; 
  549.    { 
  550.       FILE *Table;
  551.       int i;
  552.  
  553.       if (NULL == (Table = fopen (Name,"w"))) 
  554.      fprintf (stderr,"hash8: can't open hash table file '%s'\n",Name),
  555.      exit (1);
  556.       for (i=0; i<HASHLIMIT; i++)
  557.          if (HashTab[i] != NULL && *HashTab[i] != W_RESERVED) 
  558.             fprintf (Table,"%d    %d    %s\n",i,*HashTab[i],HashTab[i]+1);
  559.       fclose (Table); 
  560.    }
  561.  
  562. main (argc,argv)
  563.    int argc; char *argv[];
  564.    {
  565.       register char **h;
  566.       int Mode;
  567.  
  568.       /*
  569.        * Set up the reserved-word list.
  570.        */
  571.       while (argc > 3  &&  argv[1][0] == '-'  &&  argv[1][1] == 'r') {
  572.      argv[1] += 2;
  573.      if (argv[1][0] == '\0') {
  574.         argc--;
  575.         argv++;
  576.      }
  577.      if (Res_count == Res_max) {
  578.         Res_max += 5;
  579.         if (Reserved == NULL)
  580.            Reserved = (char **) malloc (5 * sizeof (char *));
  581.         else
  582.            Reserved = (char **)
  583.             realloc ((char *) Reserved, Res_max * sizeof (char *));
  584.      }
  585.      Reserved[Res_count] = argv[1];
  586.      Res_count++;
  587.      argc--;
  588.      argv++;
  589.       }
  590.       if (argc != 3) {
  591.          fprintf (stderr,
  592.            "usage: hash8 [-r reserved] ... (encode|[_]decode) table\n");
  593.          exit (1);
  594.       }
  595.  
  596.       /*
  597.        * If either stdin or stdout is a tty, set both unbuffered, for use
  598.        * in pipes.
  599.        * Geoff Kuenning, 11/8/86
  600.        */
  601.       if (isatty (fileno (stdin))  ||  isatty (fileno (stdout))) {
  602.      setbuf (stdin, NULL);
  603.      setbuf (stdout, NULL);
  604.       }
  605.       HashTab = (char **) malloc ((sizeof (char*)) * (HASHLIMIT));
  606.       for (h = HashTab+HASHLIMIT; --h > HashTab; ) *h = NULL;
  607.      
  608.       ReadTab(argv[2]); 
  609.       
  610.       if (!strcmp (argv[1],"encode")) Mode = ENCODE;
  611.       else if (!strcmp (argv[1],"decode")) Mode = DECODE; 
  612.       else if (!strcmp (argv[1],"_decode")) Mode = _DECODE; 
  613.       else
  614.          fprintf (stderr,"hash8: second arg must be 'encode' or 'decode'\n"),
  615.      exit (1);
  616.  
  617.       Translate (Mode);
  618.       if (NewTab) WriteTab(argv[2]);
  619.    }
  620.  
  621. SHAR_EOF
  622. fi # end of overwriting check
  623. echo shar: extracting "'lcc.sh,v'" '(11956 characters)'
  624. if test -f 'lcc.sh,v'
  625. then
  626.     echo shar: will not over-write existing file "'lcc.sh,v'"
  627. else
  628. cat << \SHAR_EOF > 'lcc.sh,v'
  629. head     1.5;
  630. access   ;
  631. symbols  ;
  632. locks    ; strict;
  633. comment  @# @;
  634.  
  635.  
  636. 1.5
  637. date     87.03.06.20.34.29;  author geoff;  state Exp;
  638. branches ;
  639. next     1.4;
  640.  
  641. 1.4
  642. date     87.02.28.00.56.50;  author geoff;  state Exp;
  643. branches ;
  644. next     1.3;
  645.  
  646. 1.3
  647. date     86.11.08.23.07.56;  author geoff;  state Exp;
  648. branches ;
  649. next     1.2;
  650.  
  651. 1.2
  652. date     86.11.08.22.15.24;  author geoff;  state Exp;
  653. branches ;
  654. next     1.1;
  655.  
  656. 1.1
  657. date     86.11.08.21.58.14;  author geoff;  state Exp;
  658. branches ;
  659. next     ;
  660.  
  661.  
  662. desc
  663. @Shell script to compile long-name C programs.
  664. @
  665.  
  666.  
  667. 1.5
  668. log
  669. @Make -p work correctly
  670. @
  671. text
  672. @: Use bin/sh
  673. #
  674. # $Header: lcc.sh,v 1.4 87/02/28 00:56:50 geoff Exp $
  675. #
  676. # $Log:    lcc.sh,v $
  677. # Revision 1.4  87/02/28  00:56:50  geoff
  678. # Major changes to handle things much better by running each compiler
  679. # pass separately.  Also add the -R switch, and support for -D and
  680. # library files.
  681. # 
  682. # Revision 1.3  86/11/08  23:07:56  geoff
  683. # Add error processing, not quite like cc's
  684. # 
  685. # Revision 1.2  86/11/08  22:15:24  geoff
  686. # Remove -HP, minor cleanup of output.  Working, except ignores errors
  687. # 
  688. # Revision 1.1  86/11/08  21:58:14  geoff
  689. # Works only if -HP specified
  690. # 
  691. #
  692. #    Replacement for the 'cc' command, with support for long
  693. #    identifiers.
  694. #
  695. #    Usage:
  696. #
  697. #    lcc [options] files
  698. #
  699. #    As with 'cc', the files mentioned can be .c, .s, or .o files.
  700. #
  701. #    All 'cc' options are support (or should be -- report bugs!).
  702. #
  703. #    There are some extra options.  All begin with H:
  704. #
  705. #    -HD    Don't preserve the encode/decode table.  (Normally, it is
  706. #        left in xxxx.t, where xxxx is the first file name encountered,
  707. #        or the -o file name if -o is specified.)
  708. #    -HA name The encode/decode table is put in <name>.  If it exists,
  709. #        the program will append to it.
  710. #    -HL    Only the C compiler itself is deficient;  the assembler
  711. #        and linker can handle long names.  Use this facility to
  712. #        generate long-name object files.  This is incompatible
  713. #        with -P and -S, but conflict is not checked.
  714. #    -R name    Add <name> to the reserved-word list.  Useful for
  715. #        library routines that have long names.
  716. #
  717. #    Options supported:
  718. #
  719. #    -I<dir>    Set include path for cpp
  720. #    -S    Generate .s files
  721. #    -c    Generate .o files;  don't load
  722. #    -n    Generate shared text (ld)
  723. #    -p    Generate profiled output
  724. #    -f*    Passed on to cc
  725. #
  726. TDIR=${TMPDIR:-/tmp}        # Where to put temp files
  727. TFILE=lcc$$            # Base name for encoded source files
  728. TMP=$TDIR/$TFILE        # Base name of cc's encoded input files
  729. TABLE=${TFILE}t            # Where the decode file goes
  730. c1sw=                # Switches for compiler pass 1
  731. ccsw=                # Switches for cc
  732. ldsw=                # Switches for ld
  733. suffix=o            # Suffix of output "object" files:  o, s, or i
  734. forceobj=-c            # How to force "objects":  -c, -P, or -S
  735. load=yes            # Yes to invoke loader
  736. numsrcfiles=            # If this is exactly one x, we kill objects
  737. ofiles=                # Files to be linked
  738. optimize=no            # -O switch specified
  739. optsw=                # Switches for optimizer
  740. preprocess=            # Preprocess option:  null, -P, or -E
  741. reserved=            # Reserved-word list
  742. rmfiles=            # List of object files to remove (only one)
  743. verbose=            # Verbose option:  -v or null
  744. killtable=no            # Yes if $TABLE is to be deleted
  745. tablename=            # Name of the output table
  746. madetable=no            # Yes if we added to the table
  747. dumbcc=no            # Yes if only cc is dumb about long names
  748.  
  749. if [ -x /lib/c ]
  750. then
  751.     COMPILER=/lib/c
  752. elif [ -x /usr/lib/c ]
  753. then
  754.     COMPILER=/usr/lib/c
  755. else
  756.     COMPILER=c
  757. fi
  758. if [ -x /lib/c2 ]
  759. then
  760.     OPTIMIZER=/lib/c2
  761. elif [ -x /usr/lib/c2 ]
  762. then
  763.     OPTIMIZER=/usr/lib/c2
  764. else
  765.     OPTIMIZER=c2
  766. fi
  767. trap '/bin/rm -f ${TFILE}.? ${TMP}* $TABLE; exit 1' 1 2 15
  768. # 7 is SIGEMT, a fairly obscure one
  769. failure=no
  770. trap "failure=yes" 7
  771. while [ $# -gt 0 ]
  772. do
  773.     case "$1" in
  774.     -HD)
  775.         TABLE=${TMP}t    # Put output table in $TMPDIR
  776.         killtable=yes
  777.         ;;
  778.     -HA)
  779.         tablename=$2
  780.         TABLE=$2
  781.         shift
  782.         ;;
  783.     -HL)
  784.         dumbcc=yes
  785.         ;;
  786.     -R)
  787.         reserved="$reserved -r $2"
  788.         shift
  789.         ;;
  790.     -n)
  791.         ldsw="$ldsw $1"
  792.         ;;
  793.     -v)
  794.         verbose=-v
  795.         ;;
  796.     -p)
  797.         ldsw="$ldsw $1"
  798.         c1sw="$c1sw -Xp"
  799.         ;;
  800.     -f*)
  801.         ldsw="$ldsw $1"
  802.         c1sw="$c1sw $1"
  803.         ;;
  804.     -o)
  805.         ldsw="$ldsw $1 $2"
  806.         tablename=$2.t
  807.         shift
  808.         ;;
  809.     -R)
  810.         ldsw="$ldsw $1 $2"
  811.         shift
  812.         ;;
  813.     -E|-P)
  814.         preprocess=$1
  815.         forceobj=$1
  816.         suffix=i
  817.         load=no
  818.         ;;
  819.     -O*)
  820.         optimize=yes
  821.         optsw=`echo $1 | tr -d O`
  822.         if [ "X$optsw" = "X-" ]
  823.         then
  824.         optsw=
  825.         fi
  826.         ;;
  827.     -C|-D*|-U*|-I*)
  828.         ccsw="$ccsw $1"
  829.         ;;
  830.     -S)
  831.         forceobj=-S
  832.         suffix=s
  833.         load=no
  834.         numsrcfiles=xx
  835.         ;;
  836.     -c)
  837.         load=no
  838.         numsrcfiles=xx
  839.         ;;
  840.     -l*)
  841.         ofiles="$ofiles $1"
  842.         ;;
  843.     *.o)
  844.         numsrcfiles=xx
  845.         ofiles="$ofiles $1"
  846.         if [ "$tablename" = "" ]
  847.         then
  848.         tablename=`basename $1 .o`.t
  849.         fi
  850.         ;;
  851.     *.s)
  852.         if  [ "$dumbcc" = "yes" -a "X$preprocess" = "X" ]
  853.         then
  854.         if cc $ccsw $verbose $forceobj $1
  855.         then
  856.             :
  857.         else
  858.             failure=yes
  859.             break
  860.         fi
  861.         elif [ "$suffix" != "s" -a "X$preprocess" = "X" ]
  862.         then
  863.         hash8 $reserved encode $TABLE < $1 > ${TMP}.s
  864.         madetable=yes
  865.         (cc $ccsw $forceobj $verbose ${TMP}.s 2> ${TMP}.e \
  866.             ||  kill -7 $$) \
  867.           | sed "s;${TMP}.s;$1;" | hash8 decode $TABLE
  868.         sed "s;${TMP}.s;$1;" ${TMP}.e | hash8 decode $TABLE 1>&2
  869.         if [ "$failure" = "yes" ]
  870.         then
  871.             break
  872.         fi
  873.         obj=`basename "$1" '.s'`.$suffix
  874.         ofiles="$ofiles $obj"
  875.         rmfiles="$rmfiles $obj"
  876.         mv ${TFILE}.$suffix $obj
  877.         numsrcfiles="x$numsrcfiles"
  878.         fi
  879.         if [ "$tablename" = "" ]
  880.         then
  881.         tablename=`basename $1 .s`.t
  882.         fi
  883.         ;;
  884.     *.c)
  885.         obj=`basename "$1" '.c'`.$suffix
  886.         ppfile=${TMP}.i
  887.         if [ "X$verbose" = "X-v" ]
  888.         then
  889.         echo "${1}:"
  890.         echo "  Preprocessing" 1>&2
  891.         fi
  892.         if [ "X$preprocess" = "X-E" ]
  893.         then
  894.         if cc $ccsw $preprocess $1
  895.         then
  896.             :
  897.         else
  898.             failure=yes
  899.         fi
  900.         elif [ "X$preprocess" = "X-P" ]
  901.         then
  902.         ppfile=$obj
  903.         fi
  904.         if cc $ccsw -E $1 > $ppfile
  905.         then
  906.         :
  907.         else
  908.         failure=yes
  909.         /bin/rm -f $ppfile
  910.         break
  911.         fi
  912.         if [ "X$preprocess" = "X-P" ]
  913.         then
  914.         break
  915.         fi
  916.         hash8 $reserved encode $TABLE < $ppfile > ${TMP}.c
  917.         madetable=yes
  918.         /bin/rm -f $ppfile
  919.         if [ "$optimize" = yes ]
  920.         then
  921.         unoptfile=${TMP}.s1
  922.         else
  923.         unoptfile=${TMP}.s
  924.         fi
  925.         if [ "X$verbose" = "X-v" ]
  926.         then
  927.         echo "  Compiling" 1>&2
  928.         fi
  929.         if $COMPILER $c1sw < ${TMP}.c > $unoptfile 2> ${TMP}.e
  930.         then
  931.         /bin/rm -f ${TMP}.c
  932.         else
  933.         hash8 decode $TABLE < ${TMP}.e 1>&2
  934.         /bin/rm $unoptfile ${TMP}.c ${TMP}.e
  935.         failure=yes
  936.         break
  937.         fi
  938.         if [ $optimize = yes ]
  939.         then
  940.         if [ "X$verbose" = "X-v" ]
  941.         then
  942.             echo "  Optimizing" 1>&2
  943.         fi
  944.         if $OPTIMIZER $optsw < $unoptfile > ${TMP}.s 2> ${TMP}.e
  945.         then
  946.             /bin/rm -f $unoptfile
  947.             unoptfile=${TMP}.s
  948.         else
  949.             hash8 decode $TABLE < ${TMP}.e 1>&2
  950.             /bin/rm -f $unoptfile ${TMP}.s ${TMP}.e
  951.             failure=yes
  952.             break
  953.         fi
  954.         fi
  955.         case "X$forceobj" in
  956.         X-S)
  957.             hash8 _decode $TABLE < $unoptfile > $obj
  958.             /bin/rm -f $unoptfile
  959.             ;;
  960.         *)
  961.             if [ "X$verbose" = "X-v" ]
  962.             then
  963.             echo "  Assembling" 1>&2
  964.             fi
  965.             if [ "$dumbcc" = "yes" ]
  966.             then
  967.             mv $unoptfile ${TMP}.s1
  968.             hash8 _decode $TABLE < ${TMP}.s1 > ${TMP}.s
  969.             /bin/rm -f ${TMP}.s1
  970.             if as -o $obj ${TMP}.s
  971.             then
  972.                 :
  973.             else
  974.                 /bin/rm -f ${TMP}.s $obj
  975.                 failure=yes
  976.                 break
  977.             fi
  978.             else
  979.             if as -o $obj $unoptfile 2> ${TMP}.e
  980.             then
  981.                 /bin/rm -f $unoptfile ${TMP}.e
  982.             else
  983.                 hash8 _decode $TABLE < ${TMP}.e 1>&2
  984.                 /bin/rm -f $unoptfile ${TMP}.e $obj
  985.                 failure=yes
  986.                 break
  987.             fi
  988.             fi
  989.             ofiles="$ofiles $obj"
  990.             rmfiles="$rmfiles $obj"
  991.             ;;
  992.         esac
  993.         numsrcfiles="x$numsrcfiles"
  994.         if [ "$tablename" = "" ]
  995.         then
  996.         tablename=`basename $1 .c`.t
  997.         fi
  998.         ;;
  999.     *)
  1000.         echo "lcc:  unrecognized argument $1, passing to cc and ld" 1>&2
  1001.         echo "type 'cat $0' to learn usage"
  1002.         ccsw="$ccsw $1"
  1003.         ldsw="$ldsw $1"
  1004.         ;;
  1005.     esac
  1006.     shift
  1007. done
  1008. if [ "$load" = yes -a "$failure" = "no" ]
  1009. then
  1010.     if [ "X$verbose" = "X-v" ]
  1011.     then
  1012.     echo "  Loading" 1>&2
  1013.     fi
  1014.     (cc $ldsw $ofiles 2> ${TMP}.e  ||  kill -7 $$) \
  1015.       | if [ "$madetable" = yes ]
  1016.         then
  1017.         hash8 _decode $TABLE
  1018.         hash8 _decode $TABLE < ${TMP}.e 1>&2
  1019.     elif [ -r "$tablename" ]
  1020.     then
  1021.         hash8 _decode $tablename
  1022.         hash8 _decode $tablename < ${TMP}.e 1>&2
  1023.     else
  1024.         cat
  1025.         cat ${TMP}.e 1>&2
  1026.     fi
  1027.     if [ "$numsrcfiles" = x ]
  1028.     then
  1029.     /bin/rm -f $rmfiles
  1030.     fi
  1031. fi
  1032. /bin/rm -f ${TFILE}.? ${TMP}*
  1033. if [ "$killtable" = "yes" -o "$tablename" = "" ]
  1034. then
  1035.     /bin/rm -f $TABLE
  1036. elif [ "$madetable" = yes -a "$TABLE" != "$tablename" ]
  1037. then
  1038.     mv $TABLE $tablename
  1039. fi
  1040. if [ "$failure" = "yes" ]
  1041. then
  1042.     exit 1
  1043. else
  1044.     exit 0
  1045. fi
  1046. @
  1047.  
  1048.  
  1049. 1.4
  1050. log
  1051. @Major changes to handle things much better by running each compiler
  1052. pass separately.  Also add the -R switch, and support for -D and
  1053. library files.
  1054. @
  1055. text
  1056. @d3 1
  1057. a3 1
  1058. # $Header: lcc.sh,v 1.3 86/11/08 23:07:56 geoff Exp $
  1059. d6 5
  1060. d59 1
  1061. d127 1
  1062. a127 1
  1063.         ccsw="$ccsw $1"
  1064. d129 4
  1065. d156 1
  1066. a156 1
  1067.     -f*|-C|-D*|-U*|-I*)
  1068. d258 1
  1069. a258 1
  1070.         if $COMPILER < ${TMP}.c > $unoptfile 2> ${TMP}.e
  1071. @
  1072.  
  1073.  
  1074. 1.3
  1075. log
  1076. @Add error processing, not quite like cc's
  1077. @
  1078. text
  1079. @d3 1
  1080. a3 1
  1081. # $Header: lcc.sh,v 1.2 86/11/08 22:15:24 geoff Exp $
  1082. d6 3
  1083. d37 3
  1084. a39 1
  1085. #        with -P and -S, but conflict is not cheked.
  1086. d61 2
  1087. d64 2
  1088. d72 19
  1089. a90 1
  1090. trap "/bin/rm -f ${TFILE}.? ${TMP}* $TABLE; exit 1" 1 2 15
  1091. a106 2
  1092.         forceobj=-S
  1093.         suffix=s
  1094. d109 4
  1095. d138 9
  1096. a146 1
  1097.     -f*|-O*|-C|-D*|-U*|-I*)
  1098. d159 3
  1099. d182 1
  1100. a182 1
  1101.         hash8 encode $TABLE < $1 > ${TMP}.s
  1102. d194 1
  1103. d204 32
  1104. a235 1
  1105.         hash8 encode $TABLE < $1 > ${TMP}.c
  1106. d237 2
  1107. a238 4
  1108.         (cc $verbose $ccsw $forceobj ${TMP}.c 2> ${TMP}.e  ||  kill -7 $$) \
  1109.           | sed "s;${TMP}.c;$1;" | hash8 decode $TABLE
  1110.         sed "s;${TMP}.c;$1;" ${TMP}.e | hash8 decode $TABLE 1>&2
  1111.         if [ "$failure" = "yes" ]
  1112. d240 15
  1113. d257 27
  1114. a283 5
  1115.         case "X${preprocess}Y$forceobj" in
  1116.         X-P*|*Y-S)
  1117.             obj=`basename "$1" '.c'`.$suffix
  1118.             hash8 _decode $TABLE < ${TFILE}.$suffix > $obj
  1119.             /bin/rm -f ${TFILE}.$suffix
  1120. d286 4
  1121. a289 1
  1122.             if [ "X$verbose" = "X-v" ]
  1123. d291 5
  1124. a295 1
  1125.                 echo "  Assembling" 1>&2
  1126. d297 2
  1127. a298 1
  1128.             if cc $ccsw -c $obj
  1129. d300 1
  1130. a300 1
  1131.                 :
  1132. d302 2
  1133. a306 2
  1134.             /bin/rm -f $obj
  1135.             obj=`basename "$1" '.c'`.o
  1136. d309 1
  1137. a310 7
  1138.         X-E*)
  1139.             ;;
  1140.         *)
  1141.             obj=`basename "$1" '.c'`.$suffix
  1142.             ofiles="$ofiles $obj"
  1143.             mv ${TFILE}.$suffix $obj
  1144.             ;;
  1145. d329 5
  1146. a333 1
  1147.     (cc $verbose $ldsw $ofiles 2> ${TMP}.e  ||  kill -7 $$) \
  1148. d337 1
  1149. d341 1
  1150. d344 2
  1151. a345 1
  1152.     fi 1>&2
  1153. d348 1
  1154. a348 1
  1155.     /bin/rm -f $ofiles
  1156. @
  1157.  
  1158.  
  1159. 1.2
  1160. log
  1161. @Remove -HP, minor cleanup of output.  Working, except ignores errors
  1162. @
  1163. text
  1164. @d3 1
  1165. a3 1
  1166. # $Header: lcc.sh,v 1.1 86/11/08 21:58:14 geoff Exp $
  1167. d6 3
  1168. d64 3
  1169. d133 7
  1170. a139 1
  1171.         cc $ccsw $verbose $forceobj $1
  1172. d144 8
  1173. a151 3
  1174.         (cc $ccsw $forceobj $verbose ${TMP}.s 2>&1 ) \
  1175.           | sed "s;${TMP}.s;$1;" \
  1176.           | hash8 decode $TABLE 1>&2
  1177. d165 1
  1178. a165 1
  1179.         (cc $verbose $ccsw $forceobj ${TMP}.c 2> ${TMP}.e ) \
  1180. d168 4
  1181. d183 7
  1182. a189 1
  1183.             cc $ccsw -c $obj
  1184. d218 1
  1185. a218 1
  1186. if [ "$load" = yes ]
  1187. d220 1
  1188. a220 1
  1189.     (cc $verbose $ldsw $ofiles 2>&1) \
  1190. d243 6
  1191. a248 1
  1192. exit
  1193. @
  1194.  
  1195.  
  1196. 1.1
  1197. log
  1198. @Works only if -HP specified
  1199. @
  1200. text
  1201. @d3 1
  1202. a3 1
  1203. # $Header$
  1204. d5 4
  1205. a8 1
  1206. # $Log$
  1207. a31 3
  1208. #    -HP    Hash before passing information to the preprocessor, rather
  1209. #        than after.  Useful if your preprocessor is dumb.  Conflicts
  1210. #        with -E and -P.
  1211. d53 1
  1212. a53 1
  1213. preprocess=            # Preprocess option:  null, -P, -E, or dumbpp
  1214. a77 4
  1215.     -HP)
  1216.         preprocess=dumbpp
  1217.         load=no
  1218.         ;;
  1219. d146 1
  1220. a146 13
  1221.         if [ "X$preprocess" = "X" ]
  1222.         then
  1223.         #
  1224.         # We preprocess before hashing so that symbols in include
  1225.         # files are picked up.  The disadvantage of this is that
  1226.         # preprocessor names are not shortened, which gives trouble
  1227.         # if your preprocessor is also dumb.  In this case,
  1228.         # specify the -HP switch.
  1229.         #
  1230.         cc $ccsw -E $1 | hash8 encode $TABLE > ${TMP}.c
  1231.         else
  1232.         hash8 encode $TABLE < $1 > ${TMP}.c
  1233.         fi
  1234. d149 1
  1235. a149 1
  1236.           | hash8 decode $TABLE
  1237. d193 1
  1238. a193 1
  1239.     (cc $ldsw $ofiles 2>&1) \
  1240. @
  1241. SHAR_EOF
  1242. chmod +x 'lcc.sh,v'
  1243. fi # end of overwriting check
  1244. echo shar: extracting "'ltest.c'" '(1175 characters)'
  1245. if test -f 'ltest.c'
  1246. then
  1247.     echo shar: will not over-write existing file "'ltest.c'"
  1248. else
  1249. cat << \SHAR_EOF > 'ltest.c'
  1250. #include <stdio.h>
  1251.  
  1252. /*
  1253.  * Test the lcc script
  1254.  */
  1255.  
  1256. int VeryLongIdentifierNumber1 = 1;
  1257. int VeryLongIdentifierNumber2 = 2;
  1258.  
  1259. void VeryLongIdentifierNumber3 ();
  1260. /*
  1261.  * The following should generate a lint complaint, because it actually
  1262.  * returns an int.
  1263.  */
  1264. extern void VeryLongIdentifierNumber4 ();
  1265.  
  1266. /*
  1267.  * The following will generate a loader error.  On some loaders, this is
  1268.  * ok;  on others it will keep you from getting an output file.  If so,
  1269.  * you will need to remove the reference below.
  1270.  */
  1271. extern int VeryLongIdentifierNumber5 ();
  1272.  
  1273. int main (argc, argv)
  1274.     register int        argc;        /* Argument count */
  1275.     register char *        argv[];        /* Argument vector */
  1276.     {
  1277.  
  1278.     /*
  1279.      * Generate a C compiler warning message.  Argv is char **, not char *.
  1280.      */
  1281.     argv = (char *) argc;
  1282.     VeryLongIdentifierNumber3 ();
  1283.     /*
  1284.      * The following is in a second file
  1285.      */
  1286.     VeryLongIdentifierNumber4 ();
  1287.     return 0;
  1288.     }
  1289.  
  1290. void VeryLongIdentifierNumber3 ()
  1291.     {
  1292.     int i = 0;
  1293.  
  1294.     printf ("should print 1 2:  %d %d\n", VeryLongIdentifierNumber1,
  1295.       VeryLongIdentifierNumber2);
  1296.     if (i)                /* Never executed - undefined ref */
  1297.     VeryLongIdentifierNumber5 ();
  1298.     }
  1299. SHAR_EOF
  1300. fi # end of overwriting check
  1301. echo shar: extracting "'ltest2.c'" '(115 characters)'
  1302. if test -f 'ltest2.c'
  1303. then
  1304.     echo shar: will not over-write existing file "'ltest2.c'"
  1305. else
  1306. cat << \SHAR_EOF > 'ltest2.c'
  1307. int VeryLongIdentifierNumber4 ()
  1308.     {
  1309.     printf ("VeryLongIdentifierNumber4 VerylongIdentifierNumber5\n");
  1310.     }
  1311. SHAR_EOF
  1312. fi # end of overwriting check
  1313. echo shar: extracting "'ltest3.c'" '(116 characters)'
  1314. if test -f 'ltest3.c'
  1315. then
  1316.     echo shar: will not over-write existing file "'ltest3.c'"
  1317. else
  1318. cat << \SHAR_EOF > 'ltest3.c'
  1319. int VeryLongIdentifierNumber4 ();
  1320.     {
  1321.     printf ("VeryLongIdentifierNumber4 VerylongIdentifierNumber5\n");
  1322.     }
  1323. SHAR_EOF
  1324. fi # end of overwriting check
  1325. echo shar: extracting "'ncc'" '(314 characters)'
  1326. if test -f 'ncc'
  1327. then
  1328.     echo shar: will not over-write existing file "'ncc'"
  1329. else
  1330. cat << \SHAR_EOF > 'ncc'
  1331.  
  1332. # Shell script for compiling long-identifier programs.
  1333. # (Must be executed by "sh", not "csh".)
  1334. #
  1335. # The long-identifier source should be named L_xxx.
  1336. # The script is then invoked with "ncc xxx"
  1337. #
  1338. cat L_$1 | hash8 encode TABLE >$1    # Convert long identifiers
  1339. cc -c $1 2>&1 | hash8 decode TABLE    # Compile short form
  1340. SHAR_EOF
  1341. fi # end of overwriting check
  1342. #    End of shell archive
  1343. exit 0
  1344.  
  1345.